// 模块内变量（避免全局污染，仅模块内可访问）
let websock = null; // WebSocket实例
let wsUrl = 'ws://localhost:8900/chat'; // 默认连接地址
let messageCallback = null; // 消息接收回调
let errorCallback = null; // 错误回调
let connectCallback = null; // 连接成功回调
let tryTime = 0; // 重连尝试次数
const maxTryTime = 10; // 最大重连次数
const reconnectInterval = 3000; // 重连间隔(ms)


/**
 * 验证发送消息的必要参数
 * @param {Object} data 待发送的消息
 * @returns {boolean|string} 验证通过返回true，否则返回错误信息
 */
function validateMessage(data) {
  const requiredFields = ['type', 'content', 'receiverType', 'receiverId', 'senderId', 'senderName'];
  const missing = requiredFields.filter(field => !(field in data));
  if (missing.length > 0) {
    return `缺少必要参数: ${missing.join(', ')}`;
  }
  return true;
}


/**
 * 接收后端消息处理
 * @param {MessageEvent} e 消息事件
 */
function handleMessage(e) {
  try {
    const data = JSON.parse(e.data);
    if (typeof messageCallback === 'function') {
      messageCallback(data);
    }
  } catch (err) {
    console.error('消息解析失败:', err);
    triggerError(new Error('消息格式错误'));
  }
}


/**
 * 连接成功处理
 */
function handleOpen() {
  console.log('WebSocket连接成功');
  tryTime = 0; // 重置重连次数
  if (typeof connectCallback === 'function') {
    connectCallback();
  }
}


/**
 * 错误处理
 * @param {Event} err 错误事件
 */
function handleError(err) {
  console.error('WebSocket错误:', err);
  triggerError(err);
}


/**
 * 关闭连接处理
 * @param {CloseEvent} e 关闭事件
 */
function handleClose(e) {
  console.log(`WebSocket关闭，代码: ${e.code}, 原因: ${e.reason}`);
  // 正常关闭（1000）不重连，其他情况尝试重连
  if (e.code !== 1000 && tryTime < maxTryTime) {
    tryTime++;
    console.log(`第${tryTime}次重连...`);
    setTimeout(initWebSocket, reconnectInterval);
  } else if (tryTime >= maxTryTime) {
    triggerError(new Error('重连次数已达上限，请检查网络'));
  }
}


/**
 * 触发错误回调
 * @param {Error} err 错误对象
 */
function triggerError(err) {
  if (typeof errorCallback === 'function') {
    errorCallback(err);
  }
}


/**
 * 初始化WebSocket连接
 * @param {Object} initData 连接成功后发送的初始消息（可选）
 */
function initWebSocket(initData) {
  // 若已存在连接，先关闭
  if (websock) {
    websock.close();
  }

  // 检查浏览器支持
  if (typeof WebSocket === 'undefined') {
    const err = new Error('您的浏览器不支持WebSocket');
    triggerError(err);
    return;
  }

  // 创建连接（可在此处添加token等参数）
  // 示例：const fullUrl = `${wsUrl}?token=${getToken()}`;
  websock = new WebSocket(wsUrl);

  // 绑定事件处理
  websock.onmessage = handleMessage;
  websock.onopen = () => {
    handleOpen();
    // 连接成功后发送初始消息
    if (initData) {
      sendMessage(initData);
    }
  };
  websock.onerror = handleError;
  websock.onclose = handleClose;
}


/**
 * 发送消息到后端
 * @param {Object} data 消息内容（需包含后端要求的参数）
 * @returns {boolean} 发送成功返回true，否则false
 */
function sendMessage(data) {
  // 验证连接状态
  if (!websock || websock.readyState !== WebSocket.OPEN) {
    console.error('WebSocket未连接，无法发送消息');
    return false;
  }

  // 验证消息参数
  const validateResult = validateMessage(data);
  if (validateResult !== true) {
    console.error(validateResult);
    return false;
  }

  // 发送消息
  try {
    websock.send(JSON.stringify(data));
    console.log('消息发送成功:', data);
    return true;
  } catch (err) {
    console.error('消息发送失败:', err);
    triggerError(err);
    return false;
  }
}


/**
 * 关闭WebSocket连接
 */
function closeWebSocket() {
  if (websock) {
    websock.close(1000, '主动关闭连接');
    websock = null;
    tryTime = 0; // 重置重连次数
  }
}


/**
 * 获取WebSocket连接状态
 * @returns {number} 0=CONNECTING, 1=OPEN, 2=CLOSING, 3=CLOSED
 */
function getReadyState() {
  if (!websock) {
    return 3; // CLOSED
  }
  return websock.readyState;
}


/**
 * 检查WebSocket是否已连接
 * @returns {boolean} 是否已连接
 */
function isConnected() {
  return websock && websock.readyState === WebSocket.OPEN;
}


/**
 * 设置WebSocket连接地址
 * @param {string} url 新的连接地址
 */
function setWsUrl(url) {
  wsUrl = url;
}


/**
 * 注册消息接收回调
 * @param {Function} callback 回调函数（参数为解析后的消息对象）
 */
function onMessage(callback) {
  if (typeof callback === 'function') {
    messageCallback = callback;
  }
}


/**
 * 注册连接成功回调
 * @param {Function} callback 回调函数
 */
function onConnect(callback) {
  if (typeof callback === 'function') {
    connectCallback = callback;
  }
}


/**
 * 注册错误回调
 * @param {Function} callback 回调函数（参数为错误对象）
 */
function onError(callback) {
  if (typeof callback === 'function') {
    errorCallback = callback;
  }
}


// 导出公共API
export default {
  init: initWebSocket, // 初始化连接（可传初始消息）
  send: sendMessage, // 发送消息
  close: closeWebSocket, // 关闭连接
  setUrl: setWsUrl, // 设置连接地址
  getReadyState, // 获取连接状态
  isConnected, // 检查是否已连接
  onMessage, // 注册消息回调
  onConnect, // 注册连接成功回调
  onError // 注册错误回调
};